/**
 * 深拷贝对象或数组，使用迭代方式避免栈溢出
 * @description 支持处理循环引用、特殊对象类型（Date、RegExp等），并使用迭代方式避免深层对象导致的栈溢出
 * @template T - 要克隆的对象类型
 * @param {T} value - 要克隆的值
 * @returns {T} 深度克隆后的值
 * @example
 * // 基础类型
 * deepClone(42); // 42
 * deepClone("text"); // "text"
 * 
 * // 数组和对象
 * const obj = { a: [1, { b: 2 }], c: new Date() };
 * const cloned = deepClone(obj);
 * 
 * // 循环引用
 * const circular = { a: 1 };
 * circular.self = circular;
 * const clonedCircular = deepClone(circular); // 正确处理循环引用
 */
export const deepClone = <T>(value: T): T => {
  // 处理特殊对象的克隆
  const cloneSpecialObject = (obj: any): any => {
    if (obj instanceof Date) return new Date(obj);
    if (obj instanceof RegExp) return new RegExp(obj);
    if (obj instanceof Map) {
      const clonedMap = new Map();
      for (const [key, val] of obj) {
        clonedMap.set(key, deepClone(val));
      }
      return clonedMap;
    }
    if (obj instanceof Set) {
      const clonedSet = new Set();
      for (const val of obj) {
        clonedSet.add(deepClone(val));
      }
      return clonedSet;
    }
    return null; // 不是特殊对象
  };

  // 使用 WeakMap 存储已克隆的对象，处理循环引用
  const cloneMap = new WeakMap();

  // 迭代方式实现深拷贝
  const deepCloneIterative = (val: any): any => {
    // 处理基础类型和 null
    if (val === null || typeof val !== 'object') {
      return val;
    }

    // 检查循环引用
    if (cloneMap.has(val)) {
      return cloneMap.get(val);
    }

    // 检查特殊对象类型
    const specialObject = cloneSpecialObject(val);
    if (specialObject !== null) {
      return specialObject;
    }

    // 创建新的数组或对象
    const clone = Array.isArray(val) ? [] : {};
    
    // 将新创建的对象添加到 cloneMap
    cloneMap.set(val, clone);

    // 使用栈存储待处理的项
    const stack: Array<{ target: any; source: any }> = [
      { target: clone, source: val }
    ];

    // 迭代处理所有嵌套属性
    while (stack.length > 0) {
      const { target, source } = stack.pop()!;
      
      // 获取所有可枚举属性，包括 Symbol
      const keys = [
        ...Object.getOwnPropertyNames(source),
        ...Object.getOwnPropertySymbols(source)
      ];

      for (const key of keys) {
        const sourceVal = source[key];

        if (sourceVal === null || typeof sourceVal !== 'object') {
          // 基础类型直接赋值
          target[key] = sourceVal;
        } else {
          // 检查是否已经克隆过
          if (cloneMap.has(sourceVal)) {
            target[key] = cloneMap.get(sourceVal);
            continue;
          }

          // 检查特殊对象类型
          const specialVal = cloneSpecialObject(sourceVal);
          if (specialVal !== null) {
            target[key] = specialVal;
            continue;
          }

          // 创建新的嵌套对象或数组
          const newTarget = Array.isArray(sourceVal) ? [] : {};
          target[key] = newTarget;
          cloneMap.set(sourceVal, newTarget);

          // 将嵌套对象添加到栈中等待处理
          stack.push({ target: newTarget, source: sourceVal });
        }
      }
    }

    return clone;
  };

  return deepCloneIterative(value);
};
